(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
    var Dumper, Inline, Utils;

    Utils = require('./Utils');

    Inline = require('./Inline');

    Dumper = (function() {
        function Dumper() {}

        Dumper.indentation = 4;

        Dumper.prototype.dump = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
            var i, key, len, output, prefix, value, willBeInlined;
            if (inline == null) {
                inline = 0;
            }
            if (indent == null) {
                indent = 0;
            }
            if (exceptionOnInvalidType == null) {
                exceptionOnInvalidType = false;
            }
            if (objectEncoder == null) {
                objectEncoder = null;
            }
            output = '';
            prefix = (indent ? Utils.strRepeat(' ', indent) : '');
            if (inline <= 0 || typeof input !== 'object' || input instanceof Date || Utils.isEmpty(input)) {
                output += prefix + Inline.dump(input, exceptionOnInvalidType, objectEncoder);
            } else {
                if (input instanceof Array) {
                    for (i = 0, len = input.length; i < len; i++) {
                        value = input[i];
                        willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
                        output += prefix + '-' + (willBeInlined ? ' ' : "\n") + this.dump(value, inline - 1, (willBeInlined ? 0 : indent + this.indentation), exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
                    }
                } else {
                    for (key in input) {
                        value = input[key];
                        willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
                        output += prefix + Inline.dump(key, exceptionOnInvalidType, objectEncoder) + ':' + (willBeInlined ? ' ' : "\n") + this.dump(value, inline - 1, (willBeInlined ? 0 : indent + this.indentation), exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
                    }
                }
            }
            return output;
        };

        return Dumper;

    })();

    module.exports = Dumper;


},{"./Inline":5,"./Utils":9}],2:[function(require,module,exports){
    var Escaper, Pattern;

    Pattern = require('./Pattern');

    Escaper = (function() {
        var ch;

        function Escaper() {}

        Escaper.LIST_ESCAPEES = ['\\\\', '\\"', '"', "\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\x07", "\x08", "\x09", "\x0a", "\x0b", "\x0c", "\x0d", "\x0e", "\x0f", "\x10", "\x11", "\x12", "\x13", "\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1a", "\x1b", "\x1c", "\x1d", "\x1e", "\x1f", (ch = String.fromCharCode)(0x0085), ch(0x00A0), ch(0x2028), ch(0x2029)];

        Escaper.LIST_ESCAPED = ['\\"', '\\\\', '\\"', "\\0", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05", "\\x06", "\\a", "\\b", "\\t", "\\n", "\\v", "\\f", "\\r", "\\x0e", "\\x0f", "\\x10", "\\x11", "\\x12", "\\x13", "\\x14", "\\x15", "\\x16", "\\x17", "\\x18", "\\x19", "\\x1a", "\\e", "\\x1c", "\\x1d", "\\x1e", "\\x1f", "\\N", "\\_", "\\L", "\\P"];

        Escaper.MAPPING_ESCAPEES_TO_ESCAPED = (function() {
            var i, j, mapping, ref;
            mapping = {};
            for (i = j = 0, ref = Escaper.LIST_ESCAPEES.length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
                mapping[Escaper.LIST_ESCAPEES[i]] = Escaper.LIST_ESCAPED[i];
            }
            return mapping;
        })();

        Escaper.PATTERN_CHARACTERS_TO_ESCAPE = new Pattern('[\\x00-\\x1f]|\xc2\x85|\xc2\xa0|\xe2\x80\xa8|\xe2\x80\xa9');

        Escaper.PATTERN_MAPPING_ESCAPEES = new Pattern(Escaper.LIST_ESCAPEES.join('|'));

        Escaper.PATTERN_SINGLE_QUOTING = new Pattern('[\\s\'":{}[\\],&*#?]|^[-?|<>=!%@`]');

        Escaper.requiresDoubleQuoting = function(value) {
            return this.PATTERN_CHARACTERS_TO_ESCAPE.test(value);
        };

        Escaper.escapeWithDoubleQuotes = function(value) {
            var result;
            result = this.PATTERN_MAPPING_ESCAPEES.replace(value, (function(_this) {
                return function(str) {
                    return _this.MAPPING_ESCAPEES_TO_ESCAPED[str];
                };
            })(this));
            return '"' + result + '"';
        };

        Escaper.requiresSingleQuoting = function(value) {
            return this.PATTERN_SINGLE_QUOTING.test(value);
        };

        Escaper.escapeWithSingleQuotes = function(value) {
            return "'" + value.replace(/'/g, "''") + "'";
        };

        return Escaper;

    })();

    module.exports = Escaper;


},{"./Pattern":7}],3:[function(require,module,exports){
    var DumpException,
        extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
        hasProp = {}.hasOwnProperty;

    DumpException = (function(superClass) {
        extend(DumpException, superClass);

        function DumpException(message, parsedLine, snippet) {
            this.message = message;
            this.parsedLine = parsedLine;
            this.snippet = snippet;
        }

        DumpException.prototype.toString = function() {
            if ((this.parsedLine != null) && (this.snippet != null)) {
                return '<DumpException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
            } else {
                return '<DumpException> ' + this.message;
            }
        };

        return DumpException;

    })(Error);

    module.exports = DumpException;


},{}],4:[function(require,module,exports){
    var ParseException,
        extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
        hasProp = {}.hasOwnProperty;

    ParseException = (function(superClass) {
        extend(ParseException, superClass);

        function ParseException(message, parsedLine, snippet) {
            this.message = message;
            this.parsedLine = parsedLine;
            this.snippet = snippet;
        }

        ParseException.prototype.toString = function() {
            if ((this.parsedLine != null) && (this.snippet != null)) {
                return '<ParseException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
            } else {
                return '<ParseException> ' + this.message;
            }
        };

        return ParseException;

    })(Error);

    module.exports = ParseException;


},{}],5:[function(require,module,exports){
    var DumpException, Escaper, Inline, ParseException, Pattern, Unescaper, Utils,
        indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };

    Pattern = require('./Pattern');

    Unescaper = require('./Unescaper');

    Escaper = require('./Escaper');

    Utils = require('./Utils');

    ParseException = require('./Exception/ParseException');

    DumpException = require('./Exception/DumpException');

    Inline = (function() {
        function Inline() {}

        Inline.REGEX_QUOTED_STRING = '(?:"(?:[^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'(?:[^\']*(?:\'\'[^\']*)*)\')';

        Inline.PATTERN_TRAILING_COMMENTS = new Pattern('^\\s*#.*$');

        Inline.PATTERN_QUOTED_SCALAR = new Pattern('^' + Inline.REGEX_QUOTED_STRING);

        Inline.PATTERN_THOUSAND_NUMERIC_SCALAR = new Pattern('^(-|\\+)?[0-9,]+(\\.[0-9]+)?$');

        Inline.PATTERN_SCALAR_BY_DELIMITERS = {};

        Inline.settings = {};

        Inline.configure = function(exceptionOnInvalidType, objectDecoder) {
            if (exceptionOnInvalidType == null) {
                exceptionOnInvalidType = null;
            }
            if (objectDecoder == null) {
                objectDecoder = null;
            }
            this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
            this.settings.objectDecoder = objectDecoder;
        };

        Inline.parse = function(value, exceptionOnInvalidType, objectDecoder) {
            var context, result;
            if (exceptionOnInvalidType == null) {
                exceptionOnInvalidType = false;
            }
            if (objectDecoder == null) {
                objectDecoder = null;
            }
            this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
            this.settings.objectDecoder = objectDecoder;
            if (value == null) {
                return '';
            }
            value = Utils.trim(value);
            if (0 === value.length) {
                return '';
            }
            context = {
                exceptionOnInvalidType: exceptionOnInvalidType,
                objectDecoder: objectDecoder,
                i: 0
            };
            switch (value.charAt(0)) {
                case '[':
                    result = this.parseSequence(value, context);
                    ++context.i;
                    break;
                case '{':
                    result = this.parseMapping(value, context);
                    ++context.i;
                    break;
                default:
                    result = this.parseScalar(value, null, ['"', "'"], context);
            }
            if (this.PATTERN_TRAILING_COMMENTS.replace(value.slice(context.i), '') !== '') {
                throw new ParseException('Unexpected characters near "' + value.slice(context.i) + '".');
            }
            return result;
        };

        Inline.dump = function(value, exceptionOnInvalidType, objectEncoder) {
            var ref, result, type;
            if (exceptionOnInvalidType == null) {
                exceptionOnInvalidType = false;
            }
            if (objectEncoder == null) {
                objectEncoder = null;
            }
            if (value == null) {
                return 'null';
            }
            type = typeof value;
            if (type === 'object') {
                if (value instanceof Date) {
                    return value.toISOString();
                } else if (objectEncoder != null) {
                    result = objectEncoder(value);
                    if (typeof result === 'string' || (result != null)) {
                        return result;
                    }
                }
                return this.dumpObject(value);
            }
            if (type === 'boolean') {
                return (value ? 'true' : 'false');
            }
            if (Utils.isDigits(value)) {
                return (type === 'string' ? "'" + value + "'" : String(parseInt(value)));
            }
            if (Utils.isNumeric(value)) {
                return (type === 'string' ? "'" + value + "'" : String(parseFloat(value)));
            }
            if (type === 'number') {
                return (value === Infinity ? '.Inf' : (value === -Infinity ? '-.Inf' : (isNaN(value) ? '.NaN' : value)));
            }
            if (Escaper.requiresDoubleQuoting(value)) {
                return Escaper.escapeWithDoubleQuotes(value);
            }
            if (Escaper.requiresSingleQuoting(value)) {
                return Escaper.escapeWithSingleQuotes(value);
            }
            if ('' === value) {
                return '""';
            }
            if (Utils.PATTERN_DATE.test(value)) {
                return "'" + value + "'";
            }
            if ((ref = value.toLowerCase()) === 'null' || ref === '~' || ref === 'true' || ref === 'false') {
                return "'" + value + "'";
            }
            return value;
        };

        Inline.dumpObject = function(value, exceptionOnInvalidType, objectSupport) {
            var j, key, len1, output, val;
            if (objectSupport == null) {
                objectSupport = null;
            }
            if (value instanceof Array) {
                output = [];
                for (j = 0, len1 = value.length; j < len1; j++) {
                    val = value[j];
                    output.push(this.dump(val));
                }
                return '[' + output.join(', ') + ']';
            } else {
                output = [];
                for (key in value) {
                    val = value[key];
                    output.push(this.dump(key) + ': ' + this.dump(val));
                }
                return '{' + output.join(', ') + '}';
            }
        };

        Inline.parseScalar = function(scalar, delimiters, stringDelimiters, context, evaluate) {
            var i, joinedDelimiters, match, output, pattern, ref, ref1, strpos, tmp;
            if (delimiters == null) {
                delimiters = null;
            }
            if (stringDelimiters == null) {
                stringDelimiters = ['"', "'"];
            }
            if (context == null) {
                context = null;
            }
            if (evaluate == null) {
                evaluate = true;
            }
            if (context == null) {
                context = {
                    exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
                    objectDecoder: this.settings.objectDecoder,
                    i: 0
                };
            }
            i = context.i;
            if (ref = scalar.charAt(i), indexOf.call(stringDelimiters, ref) >= 0) {
                output = this.parseQuotedScalar(scalar, context);
                i = context.i;
                if (delimiters != null) {
                    tmp = Utils.ltrim(scalar.slice(i), ' ');
                    if (!(ref1 = tmp.charAt(0), indexOf.call(delimiters, ref1) >= 0)) {
                        throw new ParseException('Unexpected characters (' + scalar.slice(i) + ').');
                    }
                }
            } else {
                if (!delimiters) {
                    output = scalar.slice(i);
                    i += output.length;
                    strpos = output.indexOf(' #');
                    if (strpos !== -1) {
                        output = Utils.rtrim(output.slice(0, strpos));
                    }
                } else {
                    joinedDelimiters = delimiters.join('|');
                    pattern = this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters];
                    if (pattern == null) {
                        pattern = new Pattern('^(.+?)(' + joinedDelimiters + ')');
                        this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters] = pattern;
                    }
                    if (match = pattern.exec(scalar.slice(i))) {
                        output = match[1];
                        i += output.length;
                    } else {
                        throw new ParseException('Malformed inline YAML string (' + scalar + ').');
                    }
                }
                if (evaluate) {
                    output = this.evaluateScalar(output, context);
                }
            }
            context.i = i;
            return output;
        };

        Inline.parseQuotedScalar = function(scalar, context) {
            var i, match, output;
            i = context.i;
            if (!(match = this.PATTERN_QUOTED_SCALAR.exec(scalar.slice(i)))) {
                throw new ParseException('Malformed inline YAML string (' + scalar.slice(i) + ').');
            }
            output = match[0].substr(1, match[0].length - 2);
            if ('"' === scalar.charAt(i)) {
                output = Unescaper.unescapeDoubleQuotedString(output);
            } else {
                output = Unescaper.unescapeSingleQuotedString(output);
            }
            i += match[0].length;
            context.i = i;
            return output;
        };

        Inline.parseSequence = function(sequence, context) {
            var e, i, isQuoted, len, output, ref, value;
            output = [];
            len = sequence.length;
            i = context.i;
            i += 1;
            while (i < len) {
                context.i = i;
                switch (sequence.charAt(i)) {
                    case '[':
                        output.push(this.parseSequence(sequence, context));
                        i = context.i;
                        break;
                    case '{':
                        output.push(this.parseMapping(sequence, context));
                        i = context.i;
                        break;
                    case ']':
                        return output;
                    case ',':
                    case ' ':
                    case "\n":
                        break;
                    default:
                        isQuoted = ((ref = sequence.charAt(i)) === '"' || ref === "'");
                        value = this.parseScalar(sequence, [',', ']'], ['"', "'"], context);
                        i = context.i;
                        if (!isQuoted && typeof value === 'string' && (value.indexOf(': ') !== -1 || value.indexOf(":\n") !== -1)) {
                            try {
                                value = this.parseMapping('{' + value + '}');
                            } catch (_error) {
                                e = _error;
                            }
                        }
                        output.push(value);
                        --i;
                }
                ++i;
            }
            throw new ParseException('Malformed inline YAML string ' + sequence);
        };

        Inline.parseMapping = function(mapping, context) {
            var done, i, key, len, output, shouldContinueWhileLoop, value;
            output = {};
            len = mapping.length;
            i = context.i;
            i += 1;
            shouldContinueWhileLoop = false;
            while (i < len) {
                context.i = i;
                switch (mapping.charAt(i)) {
                    case ' ':
                    case ',':
                    case "\n":
                        ++i;
                        context.i = i;
                        shouldContinueWhileLoop = true;
                        break;
                    case '}':
                        return output;
                }
                if (shouldContinueWhileLoop) {
                    shouldContinueWhileLoop = false;
                    continue;
                }
                key = this.parseScalar(mapping, [':', ' ', "\n"], ['"', "'"], context, false);
                i = context.i;
                done = false;
                while (i < len) {
                    context.i = i;
                    switch (mapping.charAt(i)) {
                        case '[':
                            value = this.parseSequence(mapping, context);
                            i = context.i;
                            if (output[key] === void 0) {
                                output[key] = value;
                            }
                            done = true;
                            break;
                        case '{':
                            value = this.parseMapping(mapping, context);
                            i = context.i;
                            if (output[key] === void 0) {
                                output[key] = value;
                            }
                            done = true;
                            break;
                        case ':':
                        case ' ':
                        case "\n":
                            break;
                        default:
                            value = this.parseScalar(mapping, [',', '}'], ['"', "'"], context);
                            i = context.i;
                            if (output[key] === void 0) {
                                output[key] = value;
                            }
                            done = true;
                            --i;
                    }
                    ++i;
                    if (done) {
                        break;
                    }
                }
            }
            throw new ParseException('Malformed inline YAML string ' + mapping);
        };

        Inline.evaluateScalar = function(scalar, context) {
            var cast, date, exceptionOnInvalidType, firstChar, firstSpace, firstWord, objectDecoder, raw, scalarLower, subValue, trimmedScalar;
            scalar = Utils.trim(scalar);
            scalarLower = scalar.toLowerCase();
            switch (scalarLower) {
                case 'null':
                case '':
                case '~':
                    return null;
                case 'true':
                    return true;
                case 'false':
                    return false;
                case '.inf':
                    return Infinity;
                case '.nan':
                    return NaN;
                case '-.inf':
                    return Infinity;
                default:
                    firstChar = scalarLower.charAt(0);
                    switch (firstChar) {
                        case '!':
                            firstSpace = scalar.indexOf(' ');
                            if (firstSpace === -1) {
                                firstWord = scalarLower;
                            } else {
                                firstWord = scalarLower.slice(0, firstSpace);
                            }
                            switch (firstWord) {
                                case '!':
                                    if (firstSpace !== -1) {
                                        return parseInt(this.parseScalar(scalar.slice(2)));
                                    }
                                    return null;
                                case '!str':
                                    return Utils.ltrim(scalar.slice(4));
                                case '!!str':
                                    return Utils.ltrim(scalar.slice(5));
                                case '!!int':
                                    return parseInt(this.parseScalar(scalar.slice(5)));
                                case '!!bool':
                                    return Utils.parseBoolean(this.parseScalar(scalar.slice(6)), false);
                                case '!!float':
                                    return parseFloat(this.parseScalar(scalar.slice(7)));
                                case '!!timestamp':
                                    return Utils.stringToDate(Utils.ltrim(scalar.slice(11)));
                                default:
                                    if (context == null) {
                                        context = {
                                            exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
                                            objectDecoder: this.settings.objectDecoder,
                                            i: 0
                                        };
                                    }
                                    objectDecoder = context.objectDecoder, exceptionOnInvalidType = context.exceptionOnInvalidType;
                                    if (objectDecoder) {
                                        trimmedScalar = Utils.rtrim(scalar);
                                        firstSpace = trimmedScalar.indexOf(' ');
                                        if (firstSpace === -1) {
                                            return objectDecoder(trimmedScalar, null);
                                        } else {
                                            subValue = Utils.ltrim(trimmedScalar.slice(firstSpace + 1));
                                            if (!(subValue.length > 0)) {
                                                subValue = null;
                                            }
                                            return objectDecoder(trimmedScalar.slice(0, firstSpace), subValue);
                                        }
                                    }
                                    if (exceptionOnInvalidType) {
                                        throw new ParseException('Custom object support when parsing a YAML file has been disabled.');
                                    }
                                    return null;
                            }
                            break;
                        case '0':
                            if ('0x' === scalar.slice(0, 2)) {
                                return Utils.hexDec(scalar);
                            } else if (Utils.isDigits(scalar)) {
                                return Utils.octDec(scalar);
                            } else if (Utils.isNumeric(scalar)) {
                                return parseFloat(scalar);
                            } else {
                                return scalar;
                            }
                            break;
                        case '+':
                            if (Utils.isDigits(scalar)) {
                                raw = scalar;
                                cast = parseInt(raw);
                                if (raw === String(cast)) {
                                    return cast;
                                } else {
                                    return raw;
                                }
                            } else if (Utils.isNumeric(scalar)) {
                                return parseFloat(scalar);
                            } else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
                                return parseFloat(scalar.replace(',', ''));
                            }
                            return scalar;
                        case '-':
                            if (Utils.isDigits(scalar.slice(1))) {
                                if ('0' === scalar.charAt(1)) {
                                    return -Utils.octDec(scalar.slice(1));
                                } else {
                                    raw = scalar.slice(1);
                                    cast = parseInt(raw);
                                    if (raw === String(cast)) {
                                        return -cast;
                                    } else {
                                        return -raw;
                                    }
                                }
                            } else if (Utils.isNumeric(scalar)) {
                                return parseFloat(scalar);
                            } else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
                                return parseFloat(scalar.replace(',', ''));
                            }
                            return scalar;
                        default:
                            if (date = Utils.stringToDate(scalar)) {
                                return date;
                            } else if (Utils.isNumeric(scalar)) {
                                return parseFloat(scalar);
                            } else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
                                return parseFloat(scalar.replace(',', ''));
                            }
                            return scalar;
                    }
            }
        };

        return Inline;

    })();

    module.exports = Inline;


},{"./Escaper":2,"./Exception/DumpException":3,"./Exception/ParseException":4,"./Pattern":7,"./Unescaper":8,"./Utils":9}],6:[function(require,module,exports){
    var Inline, ParseException, Parser, Pattern, Utils;

    Inline = require('./Inline');

    Pattern = require('./Pattern');

    Utils = require('./Utils');

    ParseException = require('./Exception/ParseException');

    Parser = (function() {
        Parser.prototype.PATTERN_FOLDED_SCALAR_ALL = new Pattern('^(?:(?<type>![^\\|>]*)\\s+)?(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$');

        Parser.prototype.PATTERN_FOLDED_SCALAR_END = new Pattern('(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$');

        Parser.prototype.PATTERN_SEQUENCE_ITEM = new Pattern('^\\-((?<leadspaces>\\s+)(?<value>.+?))?\\s*$');

        Parser.prototype.PATTERN_ANCHOR_VALUE = new Pattern('^&(?<ref>[^ ]+) *(?<value>.*)');

        Parser.prototype.PATTERN_COMPACT_NOTATION = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING + '|[^ \'"\\{\\[].*?) *\\:(\\s+(?<value>.+?))?\\s*$');

        Parser.prototype.PATTERN_MAPPING_ITEM = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING + '|[^ \'"\\[\\{].*?) *\\:(\\s+(?<value>.+?))?\\s*$');

        Parser.prototype.PATTERN_DECIMAL = new Pattern('\\d+');

        Parser.prototype.PATTERN_INDENT_SPACES = new Pattern('^ +');

        Parser.prototype.PATTERN_TRAILING_LINES = new Pattern('(\n*)$');

        Parser.prototype.PATTERN_YAML_HEADER = new Pattern('^\\%YAML[: ][\\d\\.]+.*\n');

        Parser.prototype.PATTERN_LEADING_COMMENTS = new Pattern('^(\\#.*?\n)+');

        Parser.prototype.PATTERN_DOCUMENT_MARKER_START = new Pattern('^\\-\\-\\-.*?\n');

        Parser.prototype.PATTERN_DOCUMENT_MARKER_END = new Pattern('^\\.\\.\\.\\s*$');

        Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION = {};

        Parser.prototype.CONTEXT_NONE = 0;

        Parser.prototype.CONTEXT_SEQUENCE = 1;

        Parser.prototype.CONTEXT_MAPPING = 2;

        function Parser(offset) {
            this.offset = offset != null ? offset : 0;
            this.lines = [];
            this.currentLineNb = -1;
            this.currentLine = '';
            this.refs = {};
        }

        Parser.prototype.parse = function(value, exceptionOnInvalidType, objectDecoder) {
            var alias, allowOverwrite, block, c, context, data, e, first, i, indent, isRef, j, k, key, l, lastKey, len, len1, len2, len3, lineCount, m, matches, mergeNode, n, name, parsed, parsedItem, parser, ref, ref1, ref2, refName, refValue, val, values;
            if (exceptionOnInvalidType == null) {
                exceptionOnInvalidType = false;
            }
            if (objectDecoder == null) {
                objectDecoder = null;
            }
            this.currentLineNb = -1;
            this.currentLine = '';
            this.lines = this.cleanup(value).split("\n");
            data = null;
            context = this.CONTEXT_NONE;
            allowOverwrite = false;
            while (this.moveToNextLine()) {
                if (this.isCurrentLineEmpty()) {
                    continue;
                }
                if ("\t" === this.currentLine[0]) {
                    throw new ParseException('A YAML file cannot contain tabs as indentation.', this.getRealCurrentLineNb() + 1, this.currentLine);
                }
                isRef = mergeNode = false;
                if (values = this.PATTERN_SEQUENCE_ITEM.exec(this.currentLine)) {
                    if (this.CONTEXT_MAPPING === context) {
                        throw new ParseException('You cannot define a sequence item when in a mapping');
                    }
                    context = this.CONTEXT_SEQUENCE;
                    if (data == null) {
                        data = [];
                    }
                    if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
                        isRef = matches.ref;
                        values.value = matches.value;
                    }
                    if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ').indexOf('#') === 0) {
                        if (this.currentLineNb < this.lines.length - 1 && !this.isNextLineUnIndentedCollection()) {
                            c = this.getRealCurrentLineNb() + 1;
                            parser = new Parser(c);
                            parser.refs = this.refs;
                            data.push(parser.parse(this.getNextEmbedBlock(null, true), exceptionOnInvalidType, objectDecoder));
                        } else {
                            data.push(null);
                        }
                    } else {
                        if (((ref = values.leadspaces) != null ? ref.length : void 0) && (matches = this.PATTERN_COMPACT_NOTATION.exec(values.value))) {
                            c = this.getRealCurrentLineNb();
                            parser = new Parser(c);
                            parser.refs = this.refs;
                            block = values.value;
                            indent = this.getCurrentLineIndentation();
                            if (this.isNextLineIndented(false)) {
                                block += "\n" + this.getNextEmbedBlock(indent + values.leadspaces.length + 1, true);
                            }
                            data.push(parser.parse(block, exceptionOnInvalidType, objectDecoder));
                        } else {
                            data.push(this.parseValue(values.value, exceptionOnInvalidType, objectDecoder));
                        }
                    }
                } else if ((values = this.PATTERN_MAPPING_ITEM.exec(this.currentLine)) && values.key.indexOf(' #') === -1) {
                    if (this.CONTEXT_SEQUENCE === context) {
                        throw new ParseException('You cannot define a mapping item when in a sequence');
                    }
                    context = this.CONTEXT_MAPPING;
                    if (data == null) {
                        data = {};
                    }
                    Inline.configure(exceptionOnInvalidType, objectDecoder);
                    try {
                        key = Inline.parseScalar(values.key);
                    } catch (_error) {
                        e = _error;
                        e.parsedLine = this.getRealCurrentLineNb() + 1;
                        e.snippet = this.currentLine;
                        throw e;
                    }
                    if ('<<' === key) {
                        mergeNode = true;
                        allowOverwrite = true;
                        if (((ref1 = values.value) != null ? ref1.indexOf('*') : void 0) === 0) {
                            refName = values.value.slice(1);
                            if (this.refs[refName] == null) {
                                throw new ParseException('Reference "' + refName + '" does not exist.', this.getRealCurrentLineNb() + 1, this.currentLine);
                            }
                            refValue = this.refs[refName];
                            if (typeof refValue !== 'object') {
                                throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() + 1, this.currentLine);
                            }
                            if (refValue instanceof Array) {
                                for (i = j = 0, len = refValue.length; j < len; i = ++j) {
                                    value = refValue[i];
                                    if (data[name = String(i)] == null) {
                                        data[name] = value;
                                    }
                                }
                            } else {
                                for (key in refValue) {
                                    value = refValue[key];
                                    if (data[key] == null) {
                                        data[key] = value;
                                    }
                                }
                            }
                        } else {
                            if ((values.value != null) && values.value !== '') {
                                value = values.value;
                            } else {
                                value = this.getNextEmbedBlock();
                            }
                            c = this.getRealCurrentLineNb() + 1;
                            parser = new Parser(c);
                            parser.refs = this.refs;
                            parsed = parser.parse(value, exceptionOnInvalidType);
                            if (typeof parsed !== 'object') {
                                throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() + 1, this.currentLine);
                            }
                            if (parsed instanceof Array) {
                                for (l = 0, len1 = parsed.length; l < len1; l++) {
                                    parsedItem = parsed[l];
                                    if (typeof parsedItem !== 'object') {
                                        throw new ParseException('Merge items must be objects.', this.getRealCurrentLineNb() + 1, parsedItem);
                                    }
                                    if (parsedItem instanceof Array) {
                                        for (i = m = 0, len2 = parsedItem.length; m < len2; i = ++m) {
                                            value = parsedItem[i];
                                            k = String(i);
                                            if (!data.hasOwnProperty(k)) {
                                                data[k] = value;
                                            }
                                        }
                                    } else {
                                        for (key in parsedItem) {
                                            value = parsedItem[key];
                                            if (!data.hasOwnProperty(key)) {
                                                data[key] = value;
                                            }
                                        }
                                    }
                                }
                            } else {
                                for (key in parsed) {
                                    value = parsed[key];
                                    if (!data.hasOwnProperty(key)) {
                                        data[key] = value;
                                    }
                                }
                            }
                        }
                    } else if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
                        isRef = matches.ref;
                        values.value = matches.value;
                    }
                    if (mergeNode) {

                    } else if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ').indexOf('#') === 0) {
                        if (!(this.isNextLineIndented()) && !(this.isNextLineUnIndentedCollection())) {
                            if (allowOverwrite || data[key] === void 0) {
                                data[key] = null;
                            }
                        } else {
                            c = this.getRealCurrentLineNb() + 1;
                            parser = new Parser(c);
                            parser.refs = this.refs;
                            val = parser.parse(this.getNextEmbedBlock(), exceptionOnInvalidType, objectDecoder);
                            if (allowOverwrite || data[key] === void 0) {
                                data[key] = val;
                            }
                        }
                    } else {
                        val = this.parseValue(values.value, exceptionOnInvalidType, objectDecoder);
                        if (allowOverwrite || data[key] === void 0) {
                            data[key] = val;
                        }
                    }
                } else {
                    lineCount = this.lines.length;
                    if (1 === lineCount || (2 === lineCount && Utils.isEmpty(this.lines[1]))) {
                        try {
                            value = Inline.parse(this.lines[0], exceptionOnInvalidType, objectDecoder);
                        } catch (_error) {
                            e = _error;
                            e.parsedLine = this.getRealCurrentLineNb() + 1;
                            e.snippet = this.currentLine;
                            throw e;
                        }
                        if (typeof value === 'object') {
                            if (value instanceof Array) {
                                first = value[0];
                            } else {
                                for (key in value) {
                                    first = value[key];
                                    break;
                                }
                            }
                            if (typeof first === 'string' && first.indexOf('*') === 0) {
                                data = [];
                                for (n = 0, len3 = value.length; n < len3; n++) {
                                    alias = value[n];
                                    data.push(this.refs[alias.slice(1)]);
                                }
                                value = data;
                            }
                        }
                        return value;
                    } else if ((ref2 = Utils.ltrim(value).charAt(0)) === '[' || ref2 === '{') {
                        try {
                            return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
                        } catch (_error) {
                            e = _error;
                            e.parsedLine = this.getRealCurrentLineNb() + 1;
                            e.snippet = this.currentLine;
                            throw e;
                        }
                    }
                    throw new ParseException('Unable to parse.', this.getRealCurrentLineNb() + 1, this.currentLine);
                }
                if (isRef) {
                    if (data instanceof Array) {
                        this.refs[isRef] = data[data.length - 1];
                    } else {
                        lastKey = null;
                        for (key in data) {
                            lastKey = key;
                        }
                        this.refs[isRef] = data[lastKey];
                    }
                }
            }
            if (Utils.isEmpty(data)) {
                return null;
            } else {
                return data;
            }
        };

        Parser.prototype.getRealCurrentLineNb = function() {
            return this.currentLineNb + this.offset;
        };

        Parser.prototype.getCurrentLineIndentation = function() {
            return this.currentLine.length - Utils.ltrim(this.currentLine, ' ').length;
        };

        Parser.prototype.getNextEmbedBlock = function(indentation, includeUnindentedCollection) {
            var data, indent, isItUnindentedCollection, newIndent, removeComments, removeCommentsPattern, unindentedEmbedBlock;
            if (indentation == null) {
                indentation = null;
            }
            if (includeUnindentedCollection == null) {
                includeUnindentedCollection = false;
            }
            this.moveToNextLine();
            if (indentation == null) {
                newIndent = this.getCurrentLineIndentation();
                unindentedEmbedBlock = this.isStringUnIndentedCollectionItem(this.currentLine);
                if (!(this.isCurrentLineEmpty()) && 0 === newIndent && !unindentedEmbedBlock) {
                    throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
                }
            } else {
                newIndent = indentation;
            }
            data = [this.currentLine.slice(newIndent)];
            if (!includeUnindentedCollection) {
                isItUnindentedCollection = this.isStringUnIndentedCollectionItem(this.currentLine);
            }
            removeCommentsPattern = this.PATTERN_FOLDED_SCALAR_END;
            removeComments = !removeCommentsPattern.test(this.currentLine);
            while (this.moveToNextLine()) {
                indent = this.getCurrentLineIndentation();
                if (indent === newIndent) {
                    removeComments = !removeCommentsPattern.test(this.currentLine);
                }
                if (isItUnindentedCollection && !this.isStringUnIndentedCollectionItem(this.currentLine) && indent === newIndent) {
                    this.moveToPreviousLine();
                    break;
                }
                if (this.isCurrentLineBlank()) {
                    data.push(this.currentLine.slice(newIndent));
                    continue;
                }
                if (removeComments && this.isCurrentLineComment()) {
                    if (indent === newIndent) {
                        continue;
                    }
                }
                if (indent >= newIndent) {
                    data.push(this.currentLine.slice(newIndent));
                } else if (Utils.ltrim(this.currentLine).charAt(0) === '#') {

                } else if (0 === indent) {
                    this.moveToPreviousLine();
                    break;
                } else {
                    throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
                }
            }
            return data.join("\n");
        };

        Parser.prototype.moveToNextLine = function() {
            if (this.currentLineNb >= this.lines.length - 1) {
                return false;
            }
            this.currentLine = this.lines[++this.currentLineNb];
            return true;
        };

        Parser.prototype.moveToPreviousLine = function() {
            this.currentLine = this.lines[--this.currentLineNb];
        };

        Parser.prototype.parseValue = function(value, exceptionOnInvalidType, objectDecoder) {
            var e, foldedIndent, matches, modifiers, pos, ref, ref1, val;
            if (0 === value.indexOf('*')) {
                pos = value.indexOf('#');
                if (pos !== -1) {
                    value = value.substr(1, pos - 2);
                } else {
                    value = value.slice(1);
                }
                if (this.refs[value] === void 0) {
                    throw new ParseException('Reference "' + value + '" does not exist.', this.currentLine);
                }
                return this.refs[value];
            }
            if (matches = this.PATTERN_FOLDED_SCALAR_ALL.exec(value)) {
                modifiers = (ref = matches.modifiers) != null ? ref : '';
                foldedIndent = Math.abs(parseInt(modifiers));
                if (isNaN(foldedIndent)) {
                    foldedIndent = 0;
                }
                val = this.parseFoldedScalar(matches.separator, this.PATTERN_DECIMAL.replace(modifiers, ''), foldedIndent);
                if (matches.type != null) {
                    Inline.configure(exceptionOnInvalidType, objectDecoder);
                    return Inline.parseScalar(matches.type + ' ' + val);
                } else {
                    return val;
                }
            }
            try {
                return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
            } catch (_error) {
                e = _error;
                if (((ref1 = value.charAt(0)) === '[' || ref1 === '{') && e instanceof ParseException && this.isNextLineIndented()) {
                    value += "\n" + this.getNextEmbedBlock();
                    try {
                        return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
                    } catch (_error) {
                        e = _error;
                        e.parsedLine = this.getRealCurrentLineNb() + 1;
                        e.snippet = this.currentLine;
                        throw e;
                    }
                } else {
                    e.parsedLine = this.getRealCurrentLineNb() + 1;
                    e.snippet = this.currentLine;
                    throw e;
                }
            }
        };

        Parser.prototype.parseFoldedScalar = function(separator, indicator, indentation) {
            var isCurrentLineBlank, j, len, line, matches, newText, notEOF, pattern, ref, text;
            if (indicator == null) {
                indicator = '';
            }
            if (indentation == null) {
                indentation = 0;
            }
            notEOF = this.moveToNextLine();
            if (!notEOF) {
                return '';
            }
            isCurrentLineBlank = this.isCurrentLineBlank();
            text = '';
            while (notEOF && isCurrentLineBlank) {
                if (notEOF = this.moveToNextLine()) {
                    text += "\n";
                    isCurrentLineBlank = this.isCurrentLineBlank();
                }
            }
            if (0 === indentation) {
                if (matches = this.PATTERN_INDENT_SPACES.exec(this.currentLine)) {
                    indentation = matches[0].length;
                }
            }
            if (indentation > 0) {
                pattern = this.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation];
                if (pattern == null) {
                    pattern = new Pattern('^ {' + indentation + '}(.*)$');
                    Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation] = pattern;
                }
                while (notEOF && (isCurrentLineBlank || (matches = pattern.exec(this.currentLine)))) {
                    if (isCurrentLineBlank) {
                        text += this.currentLine.slice(indentation);
                    } else {
                        text += matches[1];
                    }
                    if (notEOF = this.moveToNextLine()) {
                        text += "\n";
                        isCurrentLineBlank = this.isCurrentLineBlank();
                    }
                }
            } else if (notEOF) {
                text += "\n";
            }
            if (notEOF) {
                this.moveToPreviousLine();
            }
            if ('>' === separator) {
                newText = '';
                ref = text.split("\n");
                for (j = 0, len = ref.length; j < len; j++) {
                    line = ref[j];
                    if (line.length === 0 || line.charAt(0) === ' ') {
                        newText = Utils.rtrim(newText, ' ') + line + "\n";
                    } else {
                        newText += line + ' ';
                    }
                }
                text = newText;
            }
            if ('+' !== indicator) {
                text = Utils.rtrim(text);
            }
            if ('' === indicator) {
                text = this.PATTERN_TRAILING_LINES.replace(text, "\n");
            } else if ('-' === indicator) {
                text = this.PATTERN_TRAILING_LINES.replace(text, '');
            }
            return text;
        };

        Parser.prototype.isNextLineIndented = function(ignoreComments) {
            var EOF, currentIndentation, ret;
            if (ignoreComments == null) {
                ignoreComments = true;
            }
            currentIndentation = this.getCurrentLineIndentation();
            EOF = !this.moveToNextLine();
            if (ignoreComments) {
                while (!EOF && this.isCurrentLineEmpty()) {
                    EOF = !this.moveToNextLine();
                }
            } else {
                while (!EOF && this.isCurrentLineBlank()) {
                    EOF = !this.moveToNextLine();
                }
            }
            if (EOF) {
                return false;
            }
            ret = false;
            if (this.getCurrentLineIndentation() > currentIndentation) {
                ret = true;
            }
            this.moveToPreviousLine();
            return ret;
        };

        Parser.prototype.isCurrentLineEmpty = function() {
            var trimmedLine;
            trimmedLine = Utils.trim(this.currentLine, ' ');
            return trimmedLine.length === 0 || trimmedLine.charAt(0) === '#';
        };

        Parser.prototype.isCurrentLineBlank = function() {
            return '' === Utils.trim(this.currentLine, ' ');
        };

        Parser.prototype.isCurrentLineComment = function() {
            var ltrimmedLine;
            ltrimmedLine = Utils.ltrim(this.currentLine, ' ');
            return ltrimmedLine.charAt(0) === '#';
        };

        Parser.prototype.cleanup = function(value) {
            var count, i, indent, j, l, len, len1, line, lines, ref, ref1, ref2, smallestIndent, trimmedValue;
            if (value.indexOf("\r") !== -1) {
                value = value.split("\r\n").join("\n").split("\r").join("\n");
            }
            count = 0;
            ref = this.PATTERN_YAML_HEADER.replaceAll(value, ''), value = ref[0], count = ref[1];
            this.offset += count;
            ref1 = this.PATTERN_LEADING_COMMENTS.replaceAll(value, '', 1), trimmedValue = ref1[0], count = ref1[1];
            if (count === 1) {
                this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
                value = trimmedValue;
            }
            ref2 = this.PATTERN_DOCUMENT_MARKER_START.replaceAll(value, '', 1), trimmedValue = ref2[0], count = ref2[1];
            if (count === 1) {
                this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
                value = trimmedValue;
                value = this.PATTERN_DOCUMENT_MARKER_END.replace(value, '');
            }
            lines = value.split("\n");
            smallestIndent = -1;
            for (j = 0, len = lines.length; j < len; j++) {
                line = lines[j];
                indent = line.length - Utils.ltrim(line).length;
                if (smallestIndent === -1 || indent < smallestIndent) {
                    smallestIndent = indent;
                }
            }
            if (smallestIndent > 0) {
                for (i = l = 0, len1 = lines.length; l < len1; i = ++l) {
                    line = lines[i];
                    lines[i] = line.slice(smallestIndent);
                }
                value = lines.join("\n");
            }
            return value;
        };

        Parser.prototype.isNextLineUnIndentedCollection = function(currentIndentation) {
            var notEOF, ret;
            if (currentIndentation == null) {
                currentIndentation = null;
            }
            if (currentIndentation == null) {
                currentIndentation = this.getCurrentLineIndentation();
            }
            notEOF = this.moveToNextLine();
            while (notEOF && this.isCurrentLineEmpty()) {
                notEOF = this.moveToNextLine();
            }
            if (false === notEOF) {
                return false;
            }
            ret = false;
            if (this.getCurrentLineIndentation() === currentIndentation && this.isStringUnIndentedCollectionItem(this.currentLine)) {
                ret = true;
            }
            this.moveToPreviousLine();
            return ret;
        };

        Parser.prototype.isStringUnIndentedCollectionItem = function() {
            return this.currentLine === '-' || this.currentLine.slice(0, 2) === '- ';
        };

        return Parser;

    })();

    module.exports = Parser;


},{"./Exception/ParseException":4,"./Inline":5,"./Pattern":7,"./Utils":9}],7:[function(require,module,exports){
    var Pattern;

    Pattern = (function() {
        Pattern.prototype.regex = null;

        Pattern.prototype.rawRegex = null;

        Pattern.prototype.cleanedRegex = null;

        Pattern.prototype.mapping = null;

        function Pattern(rawRegex, modifiers) {
            var capturingBracketNumber, char, cleanedRegex, i, len, mapping, name, part, subChar;
            if (modifiers == null) {
                modifiers = '';
            }
            cleanedRegex = '';
            len = rawRegex.length;
            mapping = null;
            capturingBracketNumber = 0;
            i = 0;
            while (i < len) {
                char = rawRegex.charAt(i);
                if (char === '\\') {
                    cleanedRegex += rawRegex.slice(i, +(i + 1) + 1 || 9e9);
                    i++;
                } else if (char === '(') {
                    if (i < len - 2) {
                        part = rawRegex.slice(i, +(i + 2) + 1 || 9e9);
                        if (part === '(?:') {
                            i += 2;
                            cleanedRegex += part;
                        } else if (part === '(?<') {
                            capturingBracketNumber++;
                            i += 2;
                            name = '';
                            while (i + 1 < len) {
                                subChar = rawRegex.charAt(i + 1);
                                if (subChar === '>') {
                                    cleanedRegex += '(';
                                    i++;
                                    if (name.length > 0) {
                                        if (mapping == null) {
                                            mapping = {};
                                        }
                                        mapping[name] = capturingBracketNumber;
                                    }
                                    break;
                                } else {
                                    name += subChar;
                                }
                                i++;
                            }
                        } else {
                            cleanedRegex += char;
                            capturingBracketNumber++;
                        }
                    } else {
                        cleanedRegex += char;
                    }
                } else {
                    cleanedRegex += char;
                }
                i++;
            }
            this.rawRegex = rawRegex;
            this.cleanedRegex = cleanedRegex;
            this.regex = new RegExp(this.cleanedRegex, 'g' + modifiers.replace('g', ''));
            this.mapping = mapping;
        }

        Pattern.prototype.exec = function(str) {
            var index, matches, name, ref;
            this.regex.lastIndex = 0;
            matches = this.regex.exec(str);
            if (matches == null) {
                return null;
            }
            if (this.mapping != null) {
                ref = this.mapping;
                for (name in ref) {
                    index = ref[name];
                    matches[name] = matches[index];
                }
            }
            return matches;
        };

        Pattern.prototype.test = function(str) {
            this.regex.lastIndex = 0;
            return this.regex.test(str);
        };

        Pattern.prototype.replace = function(str, replacement) {
            this.regex.lastIndex = 0;
            return str.replace(this.regex, replacement);
        };

        Pattern.prototype.replaceAll = function(str, replacement, limit) {
            var count;
            if (limit == null) {
                limit = 0;
            }
            this.regex.lastIndex = 0;
            count = 0;
            while (this.regex.test(str) && (limit === 0 || count < limit)) {
                this.regex.lastIndex = 0;
                str = str.replace(this.regex, '');
                count++;
            }
            return [str, count];
        };

        return Pattern;

    })();

    module.exports = Pattern;


},{}],8:[function(require,module,exports){
    var Pattern, Unescaper, Utils;

    Utils = require('./Utils');

    Pattern = require('./Pattern');

    Unescaper = (function() {
        function Unescaper() {}

        Unescaper.PATTERN_ESCAPED_CHARACTER = new Pattern('\\\\([0abt\tnvfre "\\/\\\\N_LP]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})');

        Unescaper.unescapeSingleQuotedString = function(value) {
            return value.replace(/\'\'/g, '\'');
        };

        Unescaper.unescapeDoubleQuotedString = function(value) {
            if (this._unescapeCallback == null) {
                this._unescapeCallback = (function(_this) {
                    return function(str) {
                        return _this.unescapeCharacter(str);
                    };
                })(this);
            }
            return this.PATTERN_ESCAPED_CHARACTER.replace(value, this._unescapeCallback);
        };

        Unescaper.unescapeCharacter = function(value) {
            var ch;
            ch = String.fromCharCode;
            switch (value.charAt(1)) {
                case '0':
                    return ch(0);
                case 'a':
                    return ch(7);
                case 'b':
                    return ch(8);
                case 't':
                    return "\t";
                case "\t":
                    return "\t";
                case 'n':
                    return "\n";
                case 'v':
                    return ch(11);
                case 'f':
                    return ch(12);
                case 'r':
                    return ch(13);
                case 'e':
                    return ch(27);
                case ' ':
                    return ' ';
                case '"':
                    return '"';
                case '/':
                    return '/';
                case '\\':
                    return '\\';
                case 'N':
                    return ch(0x0085);
                case '_':
                    return ch(0x00A0);
                case 'L':
                    return ch(0x2028);
                case 'P':
                    return ch(0x2029);
                case 'x':
                    return Utils.utf8chr(Utils.hexDec(value.substr(2, 2)));
                case 'u':
                    return Utils.utf8chr(Utils.hexDec(value.substr(2, 4)));
                case 'U':
                    return Utils.utf8chr(Utils.hexDec(value.substr(2, 8)));
                default:
                    return '';
            }
        };

        return Unescaper;

    })();

    module.exports = Unescaper;


},{"./Pattern":7,"./Utils":9}],9:[function(require,module,exports){
    var Pattern, Utils;

    Pattern = require('./Pattern');

    Utils = (function() {
        function Utils() {}

        Utils.REGEX_LEFT_TRIM_BY_CHAR = {};

        Utils.REGEX_RIGHT_TRIM_BY_CHAR = {};

        Utils.REGEX_SPACES = /\s+/g;

        Utils.REGEX_DIGITS = /^\d+$/;

        Utils.REGEX_OCTAL = /[^0-7]/gi;

        Utils.REGEX_HEXADECIMAL = /[^a-f0-9]/gi;

        Utils.PATTERN_DATE = new Pattern('^' + '(?<year>[0-9][0-9][0-9][0-9])' + '-(?<month>[0-9][0-9]?)' + '-(?<day>[0-9][0-9]?)' + '(?:(?:[Tt]|[ \t]+)' + '(?<hour>[0-9][0-9]?)' + ':(?<minute>[0-9][0-9])' + ':(?<second>[0-9][0-9])' + '(?:\.(?<fraction>[0-9]*))?' + '(?:[ \t]*(?<tz>Z|(?<tz_sign>[-+])(?<tz_hour>[0-9][0-9]?)' + '(?::(?<tz_minute>[0-9][0-9]))?))?)?' + '$', 'i');

        Utils.LOCAL_TIMEZONE_OFFSET = new Date().getTimezoneOffset() * 60 * 1000;

        Utils.trim = function(str, char) {
            var regexLeft, regexRight;
            if (char == null) {
                char = '\\s';
            }
            return str.trim();
            regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[char];
            if (regexLeft == null) {
                this.REGEX_LEFT_TRIM_BY_CHAR[char] = regexLeft = new RegExp('^' + char + '' + char + '*');
            }
            regexLeft.lastIndex = 0;
            regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[char];
            if (regexRight == null) {
                this.REGEX_RIGHT_TRIM_BY_CHAR[char] = regexRight = new RegExp(char + '' + char + '*$');
            }
            regexRight.lastIndex = 0;
            return str.replace(regexLeft, '').replace(regexRight, '');
        };

        Utils.ltrim = function(str, char) {
            var regexLeft;
            if (char == null) {
                char = '\\s';
            }
            regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[char];
            if (regexLeft == null) {
                this.REGEX_LEFT_TRIM_BY_CHAR[char] = regexLeft = new RegExp('^' + char + '' + char + '*');
            }
            regexLeft.lastIndex = 0;
            return str.replace(regexLeft, '');
        };

        Utils.rtrim = function(str, char) {
            var regexRight;
            if (char == null) {
                char = '\\s';
            }
            regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[char];
            if (regexRight == null) {
                this.REGEX_RIGHT_TRIM_BY_CHAR[char] = regexRight = new RegExp(char + '' + char + '*$');
            }
            regexRight.lastIndex = 0;
            return str.replace(regexRight, '');
        };

        Utils.isEmpty = function(value) {
            return !value || value === '' || value === '0';
        };

        Utils.subStrCount = function(string, subString, start, length) {
            var c, i, j, len, ref, sublen;
            c = 0;
            string = '' + string;
            subString = '' + subString;
            if (start != null) {
                string = string.slice(start);
            }
            if (length != null) {
                string = string.slice(0, length);
            }
            len = string.length;
            sublen = subString.length;
            for (i = j = 0, ref = len; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
                if (subString === string.slice(i, sublen)) {
                    c++;
                    i += sublen - 1;
                }
            }
            return c;
        };

        Utils.isDigits = function(input) {
            this.REGEX_DIGITS.lastIndex = 0;
            return this.REGEX_DIGITS.test(input);
        };

        Utils.octDec = function(input) {
            this.REGEX_OCTAL.lastIndex = 0;
            return parseInt((input + '').replace(this.REGEX_OCTAL, ''), 8);
        };

        Utils.hexDec = function(input) {
            this.REGEX_HEXADECIMAL.lastIndex = 0;
            input = this.trim(input);
            if ((input + '').slice(0, 2) === '0x') {
                input = (input + '').slice(2);
            }
            return parseInt((input + '').replace(this.REGEX_HEXADECIMAL, ''), 16);
        };

        Utils.utf8chr = function(c) {
            var ch;
            ch = String.fromCharCode;
            if (0x80 > (c %= 0x200000)) {
                return ch(c);
            }
            if (0x800 > c) {
                return ch(0xC0 | c >> 6) + ch(0x80 | c & 0x3F);
            }
            if (0x10000 > c) {
                return ch(0xE0 | c >> 12) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
            }
            return ch(0xF0 | c >> 18) + ch(0x80 | c >> 12 & 0x3F) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
        };

        Utils.parseBoolean = function(input, strict) {
            var lowerInput;
            if (strict == null) {
                strict = true;
            }
            if (typeof input === 'string') {
                lowerInput = input.toLowerCase();
                if (!strict) {
                    if (lowerInput === 'no') {
                        return false;
                    }
                }
                if (lowerInput === '0') {
                    return false;
                }
                if (lowerInput === 'false') {
                    return false;
                }
                if (lowerInput === '') {
                    return false;
                }
                return true;
            }
            return !!input;
        };

        Utils.isNumeric = function(input) {
            this.REGEX_SPACES.lastIndex = 0;
            return typeof input === 'number' || typeof input === 'string' && !isNaN(input) && input.replace(this.REGEX_SPACES, '') !== '';
        };

        Utils.stringToDate = function(str) {
            var date, day, fraction, hour, info, minute, month, second, tz_hour, tz_minute, tz_offset, year;
            if (!(str != null ? str.length : void 0)) {
                return null;
            }
            info = this.PATTERN_DATE.exec(str);
            if (!info) {
                return null;
            }
            year = parseInt(info.year, 10);
            month = parseInt(info.month, 10) - 1;
            day = parseInt(info.day, 10);
            if (info.hour == null) {
                date = new Date(Date.UTC(year, month, day));
                return date;
            }
            hour = parseInt(info.hour, 10);
            minute = parseInt(info.minute, 10);
            second = parseInt(info.second, 10);
            if (info.fraction != null) {
                fraction = info.fraction.slice(0, 3);
                while (fraction.length < 3) {
                    fraction += '0';
                }
                fraction = parseInt(fraction, 10);
            } else {
                fraction = 0;
            }
            if (info.tz != null) {
                tz_hour = parseInt(info.tz_hour, 10);
                if (info.tz_minute != null) {
                    tz_minute = parseInt(info.tz_minute, 10);
                } else {
                    tz_minute = 0;
                }
                tz_offset = (tz_hour * 60 + tz_minute) * 60000;
                if ('-' === info.tz_sign) {
                    tz_offset *= -1;
                }
            }
            date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
            if (tz_offset) {
                date.setTime(date.getTime() + tz_offset);
            }
            return date;
        };

        Utils.strRepeat = function(str, number) {
            var i, res;
            res = '';
            i = 0;
            while (i < number) {
                res += str;
                i++;
            }
            return res;
        };

        Utils.getStringFromFile = function(path, callback) {
            var data, fs, j, len1, name, ref, req, xhr;
            if (callback == null) {
                callback = null;
            }
            xhr = null;
            if (typeof window !== "undefined" && window !== null) {
                if (window.XMLHttpRequest) {
                    xhr = new XMLHttpRequest();
                } else if (window.ActiveXObject) {
                    ref = ["Msxml2.XMLHTTP.6.0", "Msxml2.XMLHTTP.3.0", "Msxml2.XMLHTTP", "Microsoft.XMLHTTP"];
                    for (j = 0, len1 = ref.length; j < len1; j++) {
                        name = ref[j];
                        try {
                            xhr = new ActiveXObject(name);
                        } catch (_error) {}
                    }
                }
            }
            if (xhr != null) {
                if (callback != null) {
                    xhr.onreadystatechange = function() {
                        if (xhr.readyState === 4) {
                            if (xhr.status === 200 || xhr.status === 0) {
                                return callback(xhr.responseText);
                            } else {
                                return callback(null);
                            }
                        }
                    };
                    xhr.open('GET', path, true);
                    return xhr.send(null);
                } else {
                    xhr.open('GET', path, false);
                    xhr.send(null);
                    if (xhr.status === 200 || xhr.status === 0) {
                        return xhr.responseText;
                    }
                    return null;
                }
            } else {
                req = require;
                fs = req('fs');
                if (callback != null) {
                    return fs.readFile(path, function(err, data) {
                        if (err) {
                            return callback(null);
                        } else {
                            return callback(String(data));
                        }
                    });
                } else {
                    data = fs.readFileSync(path);
                    if (data != null) {
                        return String(data);
                    }
                    return null;
                }
            }
        };

        return Utils;

    })();

    module.exports = Utils;


},{"./Pattern":7}],10:[function(require,module,exports){
    var Dumper, Parser, Utils, Yaml;

    Parser = require('./Parser');

    Dumper = require('./Dumper');

    Utils = require('./Utils');

    Yaml = (function() {
        function Yaml() {}

        Yaml.parse = function(input, exceptionOnInvalidType, objectDecoder) {
            if (exceptionOnInvalidType == null) {
                exceptionOnInvalidType = false;
            }
            if (objectDecoder == null) {
                objectDecoder = null;
            }
            return new Parser().parse(input, exceptionOnInvalidType, objectDecoder);
        };

        Yaml.parseFile = function(path, callback, exceptionOnInvalidType, objectDecoder) {
            var input;
            if (callback == null) {
                callback = null;
            }
            if (exceptionOnInvalidType == null) {
                exceptionOnInvalidType = false;
            }
            if (objectDecoder == null) {
                objectDecoder = null;
            }
            if (callback != null) {
                return Utils.getStringFromFile(path, (function(_this) {
                    return function(input) {
                        var result;
                        result = null;
                        if (input != null) {
                            result = _this.parse(input, exceptionOnInvalidType, objectDecoder);
                        }
                        callback(result);
                    };
                })(this));
            } else {
                input = Utils.getStringFromFile(path);
                if (input != null) {
                    return this.parse(input, exceptionOnInvalidType, objectDecoder);
                }
                return null;
            }
        };

        Yaml.dump = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
            var yaml;
            if (inline == null) {
                inline = 2;
            }
            if (indent == null) {
                indent = 4;
            }
            if (exceptionOnInvalidType == null) {
                exceptionOnInvalidType = false;
            }
            if (objectEncoder == null) {
                objectEncoder = null;
            }
            yaml = new Dumper();
            yaml.indentation = indent;
            return yaml.dump(input, inline, 0, exceptionOnInvalidType, objectEncoder);
        };

        Yaml.register = function() {
            var require_handler;
            require_handler = function(module, filename) {
                return module.exports = YAML.parseFile(filename);
            };
            if ((typeof require !== "undefined" && require !== null ? require.extensions : void 0) != null) {
                require.extensions['.yml'] = require_handler;
                return require.extensions['.yaml'] = require_handler;
            }
        };

        Yaml.stringify = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
            return this.dump(input, inline, indent, exceptionOnInvalidType, objectEncoder);
        };

        Yaml.load = function(path, callback, exceptionOnInvalidType, objectDecoder) {
            return this.parseFile(path, callback, exceptionOnInvalidType, objectDecoder);
        };

        return Yaml;

    })();

    if (typeof window !== "undefined" && window !== null) {
        window.YAML = Yaml;
    }

    if (typeof window === "undefined" || window === null) {
        this.YAML = Yaml;
    }

    module.exports = Yaml;


},{"./Dumper":1,"./Parser":6,"./Utils":9}]},{},[10]);
